wolf Namespace Reference

Namespaces
namespace	autodiff
namespace	Constants
namespace	internal
namespace	SE2
namespace	SE3
namespace	SO2

Classes
class	Buffer
	Buffer for arbitrary type objects. More...
class	BufferCapture
	Buffer of Captures. More...
class	BufferFrame
	Buffer of Frames. More...
class	BufferVectorComposite
	Buffer of VectorComposite. More...
class	CaptureBase
class	CaptureDiffDrive
class	CaptureLandmarksExternal
class	CaptureMotion
	Base class for motion Captures. More...
class	CaptureOdom2d
class	CaptureOdom3d
class	CapturePose
class	CheckLog
class	Composite
class	CostFunctionWrapper
class	FactorAnalytic
class	FactorAutodiff
class	FactorAutodiff< FacT, RES, B0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 >
class	FactorAutodiff< FacT, RES, B0, B1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 >
class	FactorAutodiff< FacT, RES, B0, B1, B2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 >
class	FactorAutodiff< FacT, RES, B0, B1, B2, B3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 >
class	FactorAutodiff< FacT, RES, B0, B1, B2, B3, B4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 >
class	FactorAutodiff< FacT, RES, B0, B1, B2, B3, B4, B5, 0, 0, 0, 0, 0, 0, 0, 0, 0 >
class	FactorAutodiff< FacT, RES, B0, B1, B2, B3, B4, B5, B6, 0, 0, 0, 0, 0, 0, 0, 0 >
class	FactorAutodiff< FacT, RES, B0, B1, B2, B3, B4, B5, B6, B7, 0, 0, 0, 0, 0, 0, 0 >
class	FactorAutodiff< FacT, RES, B0, B1, B2, B3, B4, B5, B6, B7, B8, 0, 0, 0, 0, 0, 0 >
class	FactorAutodiff< FacT, RES, B0, B1, B2, B3, B4, B5, B6, B7, B8, B9, 0, 0, 0, 0, 0 >
class	FactorAutodiff< FacT, RES, B0, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, 0, 0, 0, 0 >
class	FactorAutodiff< FacT, RES, B0, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, 0, 0, 0 >
class	FactorAutodiff< FacT, RES, B0, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12, 0, 0 >
class	FactorAutodiff< FacT, RES, B0, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12, B13, 0 >
class	FactorBase
class	FactorBlockAbsolute
class	FactorBlockDifference
class	FactorDiffDrive
class	FactorDistance3d
class	FactorHomogeneous3dAbsolute
class	FactorPose2d
class	FactorPose2dWithExtrinsics
class	FactorPose3d
class	FactorPose3dWithExtrinsics
class	FactorQuaternionAbsolute
class	FactorQuaternionDifference
class	FactorRelativePose2d
class	FactorRelativePose2dWithExtrinsics
class	FactorRelativePose3d
class	FactorRelativePose3dWithExtrinsics
class	FactorRelativePosition2d
class	FactorRelativePosition2dWithExtrinsics
class	FactorRelativePosition3d
class	FactorRelativePosition3dWithExtrinsics
class	FactorVelocityLocalDirection3d
class	Factory
	Singleton template factory. More...
class	FeatureBase
class	FeatureDiffDrive
class	FeatureLandmarkExternal
struct	FeatureMatch
	Match between a feature and a feature. More...
class	FeatureMotion
class	FolderRegistry
class	FrameBase
class	GraphSearch
class	HardwareBase
class	IterationUpdateCallback
class	Landmark
class	LandmarkBase
struct	LandmarkDetection
struct	LandmarkMatch
	Match between a feature and a landmark. More...
class	LoadCore
class	Loader
class	LocalParametrizationAngle
class	LocalParametrizationBase
class	LocalParametrizationQuaternion
	Local parametrization for quaternions. More...
class	ManifoldWrapper
class	MapBase
struct	MatchLoopClosure
	Match between a capture and a capture. More...
struct	MatrixSizeCheck
struct	Motion
	One instance of the buffered data, corresponding to a particular time stamp. More...
class	MotionBuffer
	class for motion buffers. More...
class	MotionProvider
class	NodeBase
	Base class for Nodes. More...
class	NodeStateBlocks
class	Prior
class	Problem
class	ProcessorBase
class	ProcessorDiffDrive
class	ProcessorFixedWingModel
class	ProcessorLandmarkExternal
class	ProcessorLoopClosure
	General loop closure processor. More...
class	ProcessorMotion
	class for Motion processors More...
class	ProcessorOdom2d
class	ProcessorOdom3d
	Processor for 3d odometry integration. More...
class	ProcessorPose
class	ProcessorTracker
	General tracker processor. More...
class	ProcessorTrackerFeature
	Feature tracker processor. More...
class	ProcessorTrackerLandmark
	Landmark tracker processor. More...
class	ProfilingUnit
class	SensorBase
class	SensorDiffDrive
class	SensorMotionModel
class	SensorOdom
class	SensorPose
class	SolverCeres
class	SolverEigen
	Gauss-Newton solver using sparse linear solvers through Eigen (no ceres dependency) More...
class	SolverManager
	Solver manager for WOLF. More...
class	StateAngle
class	StateBlock
	class StateBlock More...
class	StateHomogeneous3d
class	StateParams
	State block for general parameters. More...
class	StatePoint2d
	State block for general 2D points and positions. More...
class	StatePoint3d
	State block for general 3D points and positions. More...
class	StateQuaternion
class	StateVector2d
	State block for general 2D vectors. More...
class	StateVector3d
	State block for general 3D vectors. More...
struct	StaticSizeCheck
struct	StaticSizeCheck< Eigen::Dynamic, DesiredSize >
class	TimeStamp
	TimeStamp implements basic functionalities for time stamps. More...
class	TrackMatrix
	Matrix of tracked features, by track and by snapshot (Captures or time stamps) This class implements the following data structure: More...
class	TrajectoryBase
class	TreeManagerBase
class	TreeManagerSlidingWindow
class	TreeManagerSlidingWindowDualRate
class	VectorComposite

Typedefs
using	ManifoldWrapperPtr = std::shared_ptr< ManifoldWrapper >
typedef EIGEN_DEFAULT_DENSE_INDEX_TYPE	SizeEigen
	Vector and Matrices size type for the Wolf project. More...
typedef std::size_t	SizeStd
	Other containers size type for the Wolf project. More...
typedef std::map< TimeStamp, FrameBasePtr >	FramePtrMap
typedef std::map< TimeStamp, FrameBaseConstPtr >	FrameConstPtrMap
typedef std::string	StateKeys
typedef Composite< bool >	BoolComposite
typedef Composite< Prior >	PriorComposite
typedef Composite< std::string >	TypeComposite
typedef std::map< FeatureBasePtr, FeatureMatchPtr >	FeatureMatchMap
	Map of feature matches. More...
typedef Factory< LandmarkBasePtr, const YAML::Node &, const std::vector< std::string > & >	FactoryLandmark
typedef Landmark< 2 >	Landmark2d
typedef Landmark< 3 >	Landmark3d
typedef std::map< FeatureBasePtr, LandmarkMatchPtr >	LandmarkMatchMap
typedef Factory< MapBasePtr, const YAML::Node &, const std::vector< std::string > & >	FactoryMapNode
typedef Factory< MapBasePtr, const std::string &, const std::vector< std::string > & >	FactoryMapFile
typedef Factory< ProcessorBasePtr, const YAML::Node &, const std::vector< std::string > & >	FactoryProcessorNode
	Processor factories classes. More...
typedef Factory< ProcessorBasePtr, const std::string &, const std::vector< std::string > & >	FactoryProcessorYaml
typedef ProcessorPose< 2 >	ProcessorPose2d
typedef ProcessorPose< 3 >	ProcessorPose3d
typedef map< TimeStamp, FeatureBasePtr >	Track
typedef map< TimeStamp, FeatureBaseConstPtr >	TrackConst
typedef map< SizeStd, FeatureBasePtr >	Snapshot
typedef map< SizeStd, FeatureBaseConstPtr >	SnapshotConst
typedef map< SizeStd, pair< FeatureBasePtr, FeatureBasePtr > >	TrackMatches
typedef map< SizeStd, pair< FeatureBaseConstPtr, FeatureBaseConstPtr > >	TrackMatchesConst
typedef Factory< SensorBasePtr, const YAML::Node &, const std::vector< std::string > & >	FactorySensorNode
	Sensor factories classes. More...
typedef Factory< SensorBasePtr, const std::string &, const std::vector< std::string > & >	FactorySensorFile
typedef SensorOdom< 2 >	SensorOdom2d
typedef SensorOdom< 3 >	SensorOdom3d
typedef SensorPose< 2 >	SensorPose2d
typedef SensorPose< 3 >	SensorPose3d
typedef Factory< std::shared_ptr< SolverManager >, const ProblemPtr &, const YAML::Node &, const std::vector< std::string > & >	FactorySolverNode
	Solver factory class. More...
typedef Factory< std::shared_ptr< SolverManager >, const ProblemPtr &, const std::string &, const std::vector< std::string > & >	FactorySolverFile
typedef Factory< std::shared_ptr< StateBlock >, const Eigen::VectorXd &, bool >	FactoryStateBlock
	StateBlock factory class. More...
typedef Factory< std::shared_ptr< StateBlock >, bool >	FactoryStateBlockIdentity
typedef Factory< Eigen::VectorXd >	FactoryStateBlockIdentityVector
typedef LocalParametrizationQuaternion< DQ_LOCAL >	LocalParametrizationHomogeneous
	Local parametrization for homogeneous vectors is equivalent to quaternion local parametrization. More...
typedef LocalParametrizationQuaternion< DQ_GLOBAL >	LocalParametrizationQuaternionGlobal
typedef LocalParametrizationQuaternion< DQ_LOCAL >	LocalParametrizationQuaternionLocal
typedef StateParams< 1 >	StateParams1
typedef StateParams< 2 >	StateParams2
typedef StateParams< 3 >	StateParams3
typedef StateParams< 4 >	StateParams4
typedef StateParams< 5 >	StateParams5
typedef StateParams< 6 >	StateParams6
typedef StateParams< 7 >	StateParams7
typedef StateParams< 8 >	StateParams8
typedef StateParams< 9 >	StateParams9
typedef StateParams< 10 >	StateParams10
typedef StateParams< 11 >	StateParams11
typedef StateParams< 12 >	StateParams12
typedef StateParams< 13 >	StateParams13
typedef StateParams< 14 >	StateParams14
typedef StateParams< 15 >	StateParams15
typedef StateParams< 16 >	StateParams16
typedef StateParams< 17 >	StateParams17
typedef StateParams< 18 >	StateParams18
typedef StateParams< 19 >	StateParams19
typedef StateParams< 20 >	StateParams20
typedef Factory< std::shared_ptr< TreeManagerBase >, const YAML::Node &, const std::vector< std::string > & >	FactoryTreeManagerNode
typedef Factory< std::shared_ptr< TreeManagerBase >, const std::string &, const std::vector< std::string > & >	FactoryTreeManagerFile
typedef std::shared_ptr< Loader >	LoaderPtr

Enumerations
enum	FactorStatus { FAC_INACTIVE = 0 , FAC_ACTIVE = 1 }
	Enumeration of factor status. More...
enum	FactorTopology {   TOP_ABS , TOP_MOTION , TOP_LOOP , TOP_LMK ,   TOP_GEOM , TOP_OTHER }
	Enumeration of factor topologies. More...
enum	JacobianMethod { JAC_AUTO = 1 , JAC_NUMERIC , JAC_ANALYTIC }
	Enumeration of jacobian computation method. More...
enum	Notification { ADD , REMOVE }
enum	QuaternionDeltaReference { DQ_LOCAL , DQ_GLOBAL }
	Local or global orientation error. More...

Functions
	WOLF_PTR_TYPEDEFS (CaptureLandmarksExternal)
	WOLF_PTR_TYPEDEFS (CaptureMotion)
	WOLF_PTR_TYPEDEFS (CaptureOdom2d)
	WOLF_PTR_TYPEDEFS (CaptureOdom3d)
	WOLF_PTR_TYPEDEFS (CapturePose)
	WOLF_PTR_TYPEDEFS (CostFunctionWrapper)
template<class T >
std::shared_ptr< ceres::NumericDiffCostFunction< T, ceres::CENTRAL, T::residualSize, T::block0Size, T::block1Size, T::block2Size, T::block3Size, T::block4Size, T::block5Size, T::block6Size, T::block7Size, T::block8Size, T::block9Size > >	createNumericDiffCostFunctionCeres (FactorBasePtr _factor_ptr)
std::shared_ptr< ceres::CostFunction >	createNumericDiffCostFunction (FactorBasePtr _fac_ptr)
	WOLF_PTR_TYPEDEFS (SolverCeres)
	WOLF_PTR_TYPEDEFS (ManifoldWrapper)
	WOLF_PTR_TYPEDEFS (NodeBase)
	WOLF_PTR_TYPEDEFS (NodeStateBlocks)
	WOLF_PTR_TYPEDEFS (Problem)
	WOLF_PTR_TYPEDEFS (TreeManagerBase)
	WOLF_PTR_TYPEDEFS (HardwareBase)
	WOLF_PTR_TYPEDEFS (SensorBase)
	WOLF_PTR_TYPEDEFS (ProcessorBase)
	WOLF_PTR_TYPEDEFS (ProcessorMotion)
	WOLF_PTR_TYPEDEFS (TrajectoryBase)
	WOLF_PTR_TYPEDEFS (FrameBase)
	WOLF_PTR_TYPEDEFS (CaptureBase)
	WOLF_PTR_TYPEDEFS (FeatureBase)
	WOLF_PTR_TYPEDEFS (FactorBase)
	WOLF_PTR_TYPEDEFS (MapBase)
	WOLF_PTR_TYPEDEFS (LandmarkBase)
	WOLF_PTR_TYPEDEFS (StateBlock)
	WOLF_PTR_TYPEDEFS (StatePoint2d)
	WOLF_PTR_TYPEDEFS (StatePoint3d)
	WOLF_PTR_TYPEDEFS (StateAngle)
	WOLF_PTR_TYPEDEFS (StateQuaternion)
	WOLF_PTR_TYPEDEFS (LocalParametrizationBase)
bool	file_exists (const std::string &_name)
const Eigen::Vector3d	gravity (void)
	WOLF_REGISTER_FOLDER ("core", _WOLF_SCHEMA_DIR)
StateKeys	keysUnion (const StateKeys &_keys1, const StateKeys &_keys2)
	Union of two sets of keys: the keys of _keys1 followed by the keys of _keys2 not in _keys1 (no duplicates) Note: 'union' is a C++ keyword. More...
StateKeys	keysIntersection (const StateKeys &_keys1, const StateKeys &_keys2)
	Intersection of two sets of keys: the keys of _keys1 that are also in _keys2, in the order of _keys1 (no duplicates) More...
void	checkTypeComposite (const TypeComposite &_types, SizeEigen _dim=0)
bool	isTypeCompositeValid (const TypeComposite &_types, SizeEigen _dim=0)
	WOLF_PTR_TYPEDEFS (FactorAnalytic)
	WOLF_PTR_TYPEDEFS (FactorBlockAbsolute)
	WOLF_PTR_TYPEDEFS (FactorBlockDifference)
	WOLF_PTR_TYPEDEFS (FactorDiffDrive)
	WOLF_PTR_TYPEDEFS (FactorDistance3d)
	WOLF_PTR_TYPEDEFS (FactorHomogeneous3dAbsolute)
	WOLF_PTR_TYPEDEFS (FactorPose2d)
	WOLF_PTR_TYPEDEFS (FactorPose2dWithExtrinsics)
	WOLF_PTR_TYPEDEFS (FactorPose3d)
	WOLF_PTR_TYPEDEFS (FactorPose3dWithExtrinsics)
	WOLF_PTR_TYPEDEFS (FactorQuaternionAbsolute)
	WOLF_PTR_TYPEDEFS (FactorQuaternionDifference)
	WOLF_PTR_TYPEDEFS (FactorRelativePose2d)
	WOLF_PTR_TYPEDEFS (FactorRelativePose2dWithExtrinsics)
	WOLF_PTR_TYPEDEFS (FactorRelativePose3d)
	WOLF_PTR_TYPEDEFS (FactorRelativePose3dWithExtrinsics)
	WOLF_PTR_TYPEDEFS (FactorRelativePosition2d)
	WOLF_PTR_TYPEDEFS (FactorRelativePosition2dWithExtrinsics)
	WOLF_PTR_TYPEDEFS (FactorRelativePosition3d)
	WOLF_PTR_TYPEDEFS (FactorRelativePosition3dWithExtrinsics)
	WOLF_PTR_TYPEDEFS (FactorVelocityLocalDirection3d)
	WOLF_PTR_TYPEDEFS (FeatureLandmarkExternal)
	WOLF_STRUCT_PTR_TYPEDEFS (FeatureMatch)
	WOLF_PTR_TYPEDEFS (FeatureMotion)
	WOLF_DECLARED_PTR_TYPEDEFS (Landmark2d)
	WOLF_DECLARED_PTR_TYPEDEFS (Landmark3d)
	WOLF_STRUCT_PTR_TYPEDEFS (LandmarkMatch)
template<typename T , int N, int RC>
bool	isSymmetric (const Eigen::Matrix< T, N, N, RC > &M, const T eps=wolf::Constants::EPS)
template<typename T , int N, int RC>
bool	isPositiveSemiDefinite (const Eigen::Matrix< T, N, N, RC > &M, const T &eps=Constants::EPS)
template<typename T , int N, int RC>
bool	isCovariance (const Eigen::Matrix< T, N, N, RC > &M, const T &eps=Constants::EPS)
template<typename T , int N, int RC>
bool	makePosDef (Eigen::Matrix< T, N, N, RC > &M, const T &eps=Constants::EPS)
Eigen::MatrixXd	computeSqrtUpper (const Eigen::MatrixXd &_info)
template<typename D1 >
Eigen::Transform< typename D1::Scalar, 2, Eigen::Isometry >	toIsometry2d (const Eigen::MatrixBase< D1 > &translation, const double &rotation)
template<typename D1 , typename D2 >
Eigen::Transform< typename D1::Scalar, 2, Eigen::Isometry >	toIsometry2d (const Eigen::MatrixBase< D1 > &translation, const Eigen::MatrixBase< D2 > &rotation)
template<typename D1 >
Eigen::Transform< typename D1::Scalar, 2, Eigen::Isometry >	toIsometry2d (const Eigen::MatrixBase< D1 > &trf)
Eigen::Isometry2d	toIsometry2d (const VectorComposite &trf)
template<typename D1 , typename D2 >
Eigen::Transform< typename D1::Scalar, 3, Eigen::Isometry >	toIsometry3d (const Eigen::MatrixBase< D1 > &translation, const Eigen::QuaternionBase< D2 > &rotation)
template<typename D1 , typename D2 >
Eigen::Transform< typename D1::Scalar, 3, Eigen::Isometry >	toIsometry3d (const Eigen::MatrixBase< D1 > &translation, const Eigen::MatrixBase< D2 > &rotation)
template<typename D1 >
Eigen::Transform< typename D1::Scalar, 3, Eigen::Isometry >	toIsometry3d (const Eigen::MatrixBase< D1 > &trf)
Eigen::Isometry3d	toIsometry3d (const VectorComposite &trf)
Eigen::Vector3d	toVector (const Eigen::Isometry2d &trf)
Eigen::Vector7d	toVector (const Eigen::Isometry3d &trf)
Eigen::Isometry3d	inverseProjectTo3d (const Eigen::Isometry2d &trf_2d)
Eigen::Isometry2d	projectTo2d (const Eigen::Isometry3d &trf_3d)
template<typename T >
T	pi2pi (const T &_angle)
	Return angle between -pi and pi This implementation uses std::remainder which makes it incompatible for autodiff::Jet (this implementation was included in math/autodiff/wolf_jet.h) More...
template<typename T >
T	toRad (const T deg)
	Conversion to radians. More...
template<typename T >
T	toDeg (const T rad)
	Conversion to degrees. More...
template<typename Derived >
Eigen::Matrix< typename Derived::Scalar, 3, 3 >	skew (const Eigen::MatrixBase< Derived > &_v)
	Skew symmetric matrix. More...
template<typename Derived >
Eigen::Matrix< typename Derived::Scalar, 3, 1 >	vee (const Eigen::MatrixBase< Derived > &_m)
	Inverse of skew symmetric matrix. More...
template<typename Derived >
Eigen::Matrix< typename Derived::Scalar, 3, 3 >	q2R (const Eigen::QuaternionBase< Derived > &_q)
	quaternion to rotation matrix conversion More...
template<typename Derived >
Eigen::Matrix< typename Derived::Scalar, 3, 3 >	q2R (const Eigen::MatrixBase< Derived > &_q)
	quaternion to rotation matrix conversion More...
template<typename Derived >
Eigen::Quaternion< typename Derived::Scalar >	R2q (const Eigen::MatrixBase< Derived > &_R)
	rotation matrix to quaternion conversion More...
template<typename D >
Eigen::Quaternion< typename D::Scalar >	e2q (const Eigen::MatrixBase< D > &_euler)
	Euler angles to quaternion. More...
template<typename Derived >
Eigen::Matrix< typename Derived::Scalar, 3, 3 >	e2R (const Eigen::MatrixBase< Derived > &_e)
	Euler angles to rotation matrix. More...
template<typename Derived >
Eigen::Matrix< typename Derived::Scalar, 3, 1 >	R2e (const Eigen::MatrixBase< Derived > &_R)
template<typename Derived >
Eigen::Matrix< typename Derived::Scalar, 3, 1 >	q2e (const Eigen::MatrixBase< Derived > &_q)
template<typename Derived >
Eigen::Matrix< typename Derived::Scalar, 3, 1 >	q2e (const Eigen::QuaternionBase< Derived > &_q)
template<typename Derived >
Eigen::MatrixBase< Derived >::Scalar	getYaw (const Eigen::MatrixBase< Derived > &_M)
template<typename Derived >
Eigen::QuaternionBase< Derived >::Scalar	getYaw (const Eigen::QuaternionBase< Derived > &_q)
template<typename Derived >
Eigen::Quaternion< typename Derived::Scalar >	exp_q (const Eigen::MatrixBase< Derived > &_v)
	Quaternion exponential map. More...
template<typename Derived >
Eigen::Matrix< typename Derived::Scalar, 3, 1 >	log_q (const Eigen::QuaternionBase< Derived > &_q)
	Quaternion logarithmic map. More...
template<typename Derived >
Eigen::Matrix< typename Derived::Scalar, 3, 3 >	exp_R (const Eigen::MatrixBase< Derived > &_v)
	Rotation matrix exponential map. More...
template<typename Derived >
Eigen::Matrix< typename Derived::Scalar, 3, 1 >	log_R (const Eigen::MatrixBase< Derived > &_R)
	Rotation matrix logarithmic map. More...
template<typename Derived >
Eigen::Quaternion< typename Derived::Scalar >	v2q (const Eigen::MatrixBase< Derived > &_v)
	Rotation vector to quaternion conversion. More...
template<typename Derived >
Eigen::Matrix< typename Derived::Scalar, 3, 1 >	q2v (const Eigen::QuaternionBase< Derived > &_q)
	Quaternion to rotation vector conversion. More...
template<typename Derived >
Eigen::Matrix< typename Derived::Scalar, 3, 3 >	v2R (const Eigen::MatrixBase< Derived > &_v)
	Rotation vector to rotation matrix conversion. More...
template<typename Derived >
Eigen::Matrix< typename Derived::Scalar, 3, 1 >	R2v (const Eigen::MatrixBase< Derived > &_R)
	Rotation matrix to rotation vector conversion. More...
template<typename Derived >
Eigen::Matrix< typename Derived::Scalar, 3, 3 >	jac_SO3_right (const Eigen::MatrixBase< Derived > &_theta)
	Compute Jr (Right Jacobian) Right Jacobian for exp map in SO(3) - equation (10.86) and following equations in G.S. Chirikjian, "Stochastic Models, Information Theory, and Lie Groups", Volume 2, 2008. More...
template<typename Derived >
Eigen::Matrix< typename Derived::Scalar, 3, 3 >	jac_SO3_right_inv (const Eigen::MatrixBase< Derived > &_theta)
	Compute Jrinv (inverse of Right Jacobian which corresponds to the jacobian of log) Right Jacobian for Log map in SO(3) - equation (10.86) and following equations in G.S. Chirikjian, "Stochastic Models, Information Theory, and Lie Groups", Volume 2, 2008. More...
template<typename Derived >
Eigen::Matrix< typename Derived::Scalar, 3, 3 >	jac_SO3_left (const Eigen::MatrixBase< Derived > &_theta)
	Compute Jl (Left Jacobian) Left Jacobian for exp map in SO(3) - equation (10.86) and following equations in G.S. Chirikjian, "Stochastic Models, Information Theory, and Lie Groups", Volume 2, 2008. More...
template<typename Derived >
Eigen::Matrix< typename Derived::Scalar, 3, 3 >	jac_SO3_left_inv (const Eigen::MatrixBase< Derived > &_theta)
	Compute Jl_inv (inverse of Left Jacobian which corresponds to the jacobian of log) Left Jacobian for Log map in SO(3) - equation (10.86) and following equations in G.S. Chirikjian, "Stochastic Models, Information Theory, and Lie Groups", Volume 2, 2008. More...
template<typename D1 , typename D2 , typename D3 , typename D4 , typename D5 >
void	compose (const Eigen::QuaternionBase< D1 > &_q1, const Eigen::QuaternionBase< D2 > &_q2, Eigen::QuaternionBase< D3 > &_q_comp, Eigen::MatrixBase< D4 > &_J_comp_q1, Eigen::MatrixBase< D5 > &_J_comp_q2)
template<typename D1 , typename D2 , typename D3 , typename D4 , typename D5 >
void	between (const Eigen::QuaternionBase< D1 > &_q1, const Eigen::QuaternionBase< D2 > &_q2, Eigen::QuaternionBase< D3 > &_q_between, Eigen::MatrixBase< D4 > &_J_between_q1, Eigen::MatrixBase< D5 > &_J_between_q2)
template<typename D1 , typename D2 >
Eigen::Quaternion< typename D1::Scalar >	plus_right (const Eigen::QuaternionBase< D1 > &q, const Eigen::MatrixBase< D2 > &v)
template<typename D1 , typename D2 >
Eigen::Matrix< typename D2::Scalar, 3, 1 >	minus_right (const Eigen::QuaternionBase< D1 > &q1, const Eigen::QuaternionBase< D2 > &q2)
template<typename D1 , typename D2 >
Eigen::Quaternion< typename D1::Scalar >	plus_left (const Eigen::MatrixBase< D2 > &v, const Eigen::QuaternionBase< D1 > &q)
template<typename D1 , typename D2 >
Eigen::Matrix< typename D2::Scalar, 3, 1 >	minus_left (const Eigen::QuaternionBase< D1 > &q1, const Eigen::QuaternionBase< D2 > &q2)
template<typename D1 , typename D2 >
Eigen::Quaternion< typename D1::Scalar >	plus (const Eigen::QuaternionBase< D1 > &q, const Eigen::MatrixBase< D2 > &v)
template<typename D1 , typename D2 >
Eigen::Matrix< typename D2::Scalar, 3, 1 >	minus (const Eigen::QuaternionBase< D1 > &q1, const Eigen::QuaternionBase< D2 > &q2)
template<typename D1 , typename D2 >
Eigen::Matrix< typename D2::Scalar, 3, 1 >	diff (const Eigen::QuaternionBase< D1 > &q1, const Eigen::QuaternionBase< D2 > &q2)
	WOLF_PTR_TYPEDEFS (MotionProvider)
	WOLF_PTR_TYPEDEFS (ProcessorDiffDrive)
	WOLF_PTR_TYPEDEFS (ProcessorFixedWingModel)
	WOLF_PTR_TYPEDEFS (ProcessorLandmarkExternal)
	WOLF_STRUCT_PTR_TYPEDEFS (MatchLoopClosure)
	WOLF_PTR_TYPEDEFS (ProcessorOdom2d)
	WOLF_PTR_TYPEDEFS (ProcessorOdom3d)
	WOLF_DECLARED_PTR_TYPEDEFS (ProcessorPose2d)
	WOLF_DECLARED_PTR_TYPEDEFS (ProcessorPose3d)
	WOLF_PTR_TYPEDEFS (ProcessorTracker)
	WOLF_PTR_TYPEDEFS (ProcessorTrackerFeature)
	WOLF_PTR_TYPEDEFS (ProcessorTrackerLandmark)
	WOLF_PTR_TYPEDEFS (SensorDiffDrive)
	WOLF_PTR_TYPEDEFS (SensorMotionModel)
	WOLF_DECLARED_PTR_TYPEDEFS (SensorOdom2d)
	WOLF_DECLARED_PTR_TYPEDEFS (SensorOdom3d)
	WOLF_DECLARED_PTR_TYPEDEFS (SensorPose2d)
	WOLF_DECLARED_PTR_TYPEDEFS (SensorPose3d)
	WOLF_PTR_TYPEDEFS (SolverEigen)
std::string	dateTimeNow ()
void	insertSparseBlock (const Eigen::MatrixXd &ins, Eigen::SparseMatrixd &original, const unsigned int &row, const unsigned int &col)
std::ostream &	operator<< (std::ostream &os, const TimeStamp &_ts)
std::ostream &	operator<< (std::ostream &_os, const wolf::Prior &_x)
std::ostream &	operator<< (std::ostream &_os, const wolf::VectorComposite &_x)
	WOLF_REGISTER_LANDMARK (Landmark2d)
	WOLF_REGISTER_LANDMARK (Landmark3d)
	WOLF_REGISTER_MAP (MapBase)
	WOLF_REGISTER_PROCESSOR (ProcessorDiffDrive)
	WOLF_REGISTER_PROCESSOR (ProcessorFixedWingModel)
	WOLF_REGISTER_PROCESSOR (ProcessorOdom2d)
	WOLF_REGISTER_PROCESSOR (ProcessorOdom3d)
	WOLF_REGISTER_PROCESSOR (ProcessorPose2d)
	WOLF_REGISTER_PROCESSOR (ProcessorPose3d)
	WOLF_REGISTER_SENSOR (SensorDiffDrive)
	WOLF_REGISTER_SENSOR (SensorMotionModel)
	WOLF_REGISTER_SENSOR (SensorOdom2d)
	WOLF_REGISTER_SENSOR (SensorOdom3d)
	WOLF_REGISTER_SENSOR (SensorPose2d)
	WOLF_REGISTER_SENSOR (SensorPose3d)
static std::string	stringPrintf (const char *format,...)
static double	secondsSince (const std::chrono::steady_clock::time_point &_t)
	WOLF_REGISTER_STATEBLOCK (StateQuaternion)
	WOLF_REGISTER_STATEBLOCK (StateAngle)
	WOLF_REGISTER_STATEBLOCK (StateHomogeneous3d)
	WOLF_REGISTER_STATEBLOCK (StatePoint2d)
	WOLF_REGISTER_STATEBLOCK (StateVector2d)
	WOLF_REGISTER_STATEBLOCK (StatePoint3d)
	WOLF_REGISTER_STATEBLOCK (StateVector3d)
	WOLF_REGISTER_STATEBLOCK (StateParams1)
	WOLF_REGISTER_STATEBLOCK (StateParams2)
	WOLF_REGISTER_STATEBLOCK (StateParams3)
	WOLF_REGISTER_STATEBLOCK (StateParams4)
	WOLF_REGISTER_STATEBLOCK (StateParams5)
	WOLF_REGISTER_STATEBLOCK (StateParams6)
	WOLF_REGISTER_STATEBLOCK (StateParams7)
	WOLF_REGISTER_STATEBLOCK (StateParams8)
	WOLF_REGISTER_STATEBLOCK (StateParams9)
	WOLF_REGISTER_STATEBLOCK (StateParams10)
	WOLF_REGISTER_STATEBLOCK (StateParams11)
	WOLF_REGISTER_STATEBLOCK (StateParams12)
	WOLF_REGISTER_STATEBLOCK (StateParams13)
	WOLF_REGISTER_STATEBLOCK (StateParams14)
	WOLF_REGISTER_STATEBLOCK (StateParams15)
	WOLF_REGISTER_STATEBLOCK (StateParams16)
	WOLF_REGISTER_STATEBLOCK (StateParams17)
	WOLF_REGISTER_STATEBLOCK (StateParams18)
	WOLF_REGISTER_STATEBLOCK (StateParams19)
	WOLF_REGISTER_STATEBLOCK (StateParams20)
	WOLF_REGISTER_TREE_MANAGER (TreeManagerSlidingWindow)
	WOLF_REGISTER_TREE_MANAGER (TreeManagerSlidingWindowDualRate)

Variables
static std::string	ALL_KEYS = " "
static constexpr unsigned int	NO_ROW = std::numeric_limits<unsigned int>::max()
static constexpr double	cauchy_a2 = 0.5 * 0.5
static constexpr unsigned int	max_step_halvings = 10

Typedef Documentation

BoolComposite

typedef Composite<bool> wolf::BoolComposite

FactoryLandmark

typedef Factory<LandmarkBasePtr, const YAML::Node&, const std::vector<std::string>&> wolf::FactoryLandmark

FactoryMapFile

typedef Factory<MapBasePtr, const std::string&, const std::vector<std::string>&> wolf::FactoryMapFile

FactoryMapNode

typedef Factory<MapBasePtr, const YAML::Node&, const std::vector<std::string>&> wolf::FactoryMapNode

FactoryProcessorNode

typedef Factory<ProcessorBasePtr, const YAML::Node&, const std::vector<std::string>&> wolf::FactoryProcessorNode

Processor factories classes.

These factories can create objects of classes deriving from ProcessorBase.

Specific object creation is invoked by create(TYPE, params ... ), and the TYPE of Processor is identified with a string. Currently, the following Processor types are implemented,

• "ProcessorOdom2d" for ProcessorOdom2d
• "ProcessorOdom3d" for ProcessorOdom3d
• "ProcessorDiffDrive" for ProcessorDiffDrive

among others.

There are two factories, from a YAML file and from a YAML node with the following objectives:

• The creator from YAML file validates the YAML params before creating the object.
• The creator from YAML node only validates the YAML params _schema_folders vector is not empty.

Validation of YAML params is performed via yaml_schema_cpp library, the schema file (with the name of the class) will be recursively searched in the folders provided in _schema_folders vector.

Find general Factory documentation in class Factory:

• Access the factory
• Register/unregister creators
• Invoke object creation

This documentation shows you how to use the FactoryProcessorNode specifically:

• Write processor creators.
• Create processors

Write processor creators

Processor creators have the following API:

\code
static ProcessorBasePtr create(const YAML::Node& _yaml_node,
                               std::vector<std::string>& _folders_schema);
static ProcessorBasePtr create(const std::string& _yaml_filepath,
                               std::vector<std::string>& _folders_schema);
\endcode

They follow the general implementations shown below (example for class ProcessorDiffDrive):

\code
static ProcessorBasePtr create(const YAML::Node& _input_node,
                               std::vector<std::string>& _folders_schema={})
{
    // validate the _input_node if provided folders where to find the schema file
    if (not _folders_schema.empty())
    {
        auto server = yaml_schema_cpp::YamlServer(_folders_schema);
        server.setYaml(_input_node);
        if (not server.applySchema("ProcessorDiffDrive"))
        {
            WOLF_ERROR(server.getLog());
            return nullptr;
        }
    }
    // Do create the Processor object
    return std::make_shared<ProcessorDiffDrive>(params);
}
static ProcessorBasePtr create(const std::string& _yaml_filepath,
                               std::vector<std::string>& _folders_schema)
{
    // parse the yaml file
    auto server = yaml_schema_cpp::YamlServer(_folders_schema, _yaml_filepath);
    // Check that the yaml has all necessary inforamtion
    if (not server.applySchema("ProcessorDiffDrive"))
    {
        WOLF_ERROR(server.getLog());
        return nullptr;
    }
    // Do create the Processor object (calling the previous creator)
    return create(server.getNode(), {});
}
\endcode

Creating processors

Note: Prior to invoking the creation of a processor of a particular type, you must register the creator for this type into the factory.

To create e.g. a ProcessorDiffDrive in 3D, you type:

\code
auto proc_diff_drive_ptr = FactoryProcessorNode::create("ProcessorDiffDrive", yaml_node);
\endcode

or:

\code
auto proc_diff_drive_ptr = FactoryProcessorFile::create("ProcessorDiffDrive",
                                                        "path_of_params_file.yaml",
                                                        schema_folders_vector);
\endcode

where ABSOLUTELY ALL input parameters are important. DO NOT USE IT WITH DUMMY PARAMETERS!

We RECOMMEND using the macro WOLF_PROCESSOR_CREATE(ProcessorClass) to automatically generate the processor creators, provided in 'processor_base.h'.

To do so, you should implement a constructor with the API:

\code
ProcessorDerived(const YAML::Node& _params)
\endcode

In case of processors templated to the dimension of the problem (non-type template), there is also the WOLF_PROCESSOR_TEMPLATE_DIM_CREATE(ProcessorDerived, DIM). See processor_odom.h for an example.

Registering processor creator into the factory

Registration can be done manually or automatically. It involves the call to static functions. It is advisable to put these calls within unnamed namespaces.

• Manual registration: you control registration at application level. Put the code either at global scope (you must define a dummy variable for this),

  namespace {
  const bool registered_proc_diff_drive_node = FactoryProcessorNode::registerCreator("ProcessorDiffDrive",
                                                                                      ProcessorDiffDrive::create);
  }
  namespace {
  const bool registered_proc_diff_drive_file = FactoryProcessorFile::registerCreator("ProcessorDiffDrive",
                                                                                      ProcessorDiffDrive::create);
  }
  main () { ... }

  or inside your main(), where a direct call is possible:

  main () {
      FactoryProcessorNode::registerCreator("ProcessorDiffDrive", ProcessorDiffDrive::create);
      FactoryProcessorFile::registerCreator("ProcessorDiffDrive", ProcessorDiffDrive::create);
      ...
  }

• Automatic registration: registration is performed at library level. Put the code at the last line of the processor_xxx.cpp file,

  namespace {
  const bool registered_proc_diff_drive_node = FactoryProcessorNode::registerCreator("ProcessorDiffDrive",
                                                                                     ProcessorDiffDrive::create);
  const bool registered_proc_diff_drive_file = FactoryProcessorFile::registerCreator("ProcessorDiffDrive",
                                                                                     ProcessorDiffDrive::create);
  }

  Automatic registration is recommended in wolf, and implemented in the classes shipped with it using the macro WOLF_REGISTER_PROCESSOR(ProcessorType). You are free to comment out these lines and place them wherever you consider it more convenient for your design.

Creating processors

We finally provide the necessary steps to create a processor of class ProcessorDiffDrive in our application:

#include "vision/processor/processor_diff_drive.h" // provides ProcessorDiffDrive
 
// Note: ProcessorDiffDrive::create() is already registered, automatically.
 
using namespace wolf;
int main() {
 
    // To create a proc_diff_drive, provide:
    //    a type = "ProcessorDiffDrive",
    //    a name = "Front-left proc_diff_drive",
    //    the problem dimension dim = 3, and
    //    the yaml node or a yaml file
 
    ProcessorBasePtr proc_diff_drive_1_ptr =
        FactoryProcessorNode::create ( "ProcessorDiffDrive", parameter_node );
 
    // A second proc_diff_drive... with a different name specified in the yaml file or the parameters!
 
    ProcessorBasePtr proc_diff_drive_2_ptr =
        FactoryProcessorNode::create( "ProcessorDiffDrive", yaml_filename );
 
    return 0;
}

See also

• Problem::installProcessor() : to install processors in WOLF Problem.

FactoryProcessorYaml

typedef Factory<ProcessorBasePtr, const std::string&, const std::vector<std::string>&> wolf::FactoryProcessorYaml

FactorySensorFile

typedef Factory<SensorBasePtr, const std::string&, const std::vector<std::string>&> wolf::FactorySensorFile

FactorySensorNode

typedef Factory<SensorBasePtr, const YAML::Node&, const std::vector<std::string>&> wolf::FactorySensorNode

Sensor factories classes.

These factories can create objects of classes deriving from SensorBase.

Specific object creation is invoked by create(TYPE, params ... ), and the TYPE of sensor is identified with a string. Currently, the following sensor types are implemented,

• "SensorOdom2d" for SensorOdom2d
• "SensorOdom3d" for SensorOdom3d
• "SensorDiffDrive" for SensorDiffDrive
• "SensorCamera" for SensorCamera // in plugin 'vision'
• "SensorLaser2d" for SensorLaser2d // in plugin 'laser'

among others.

There are two factories, from a YAML file and from a YAML node with the following objectives:

• The creator from YAML file validates the YAML params before creating the object.
• The creator from YAML node only validates the YAML params _schema_folders vector is not empty.

Validation of YAML params is performed via yaml_schema_cpp library, the schema file (with the name of the class) will be recursively searched in the folders provided in _schema_folders vector.

Find general Factory documentation in class Factory:

• Access the factory
• Register/unregister creators
• Invoke object creation

This documentation shows you how to use the FactorySensorNode specifically:

• Write sensor creators.
• Create sensors

Write sensor creators

Sensor creators have the following API:

\code
static SensorBasePtr create(const YAML::Node& _yaml_node,
                            std::vector<std::string>& _folders_schema);
static SensorBasePtr create(const std::string& _yaml_filepath,
                            std::vector<std::string>& _folders_schema);
\endcode

They follow the general implementations shown below (example for class SensorCamera)

\code
static SensorBasePtr create(const YAML::Node& _input_node,
                            std::vector<std::string>& _folders_schema={})
{
    // validate the _input_node if provided folders where to find the schema file
    if (not _folders_schema.empty())
    {
        auto server = yaml_schema_cpp::YamlServer(_folders_schema);
        server.setYaml(_input_node);
        if (not server.applySchema("SensorCamera"))
        {
            WOLF_ERROR(server.getLog());
            return nullptr;
        }
    }
    // Do create the Sensor object
    return std::make_shared<SensorCamera>(params);
}
static SensorBasePtr create(const std::string& _yaml_filepath,
                            std::vector<std::string>& _folders_schema)
{
    // parse the yaml file
    auto server = yaml_schema_cpp::YamlServer(_folders_schema, _yaml_filepath);
    // Check that the yaml has all necessary inforamtion
    if (not server.applySchema("SensorCamera"))
    {
        WOLF_ERROR(server.getLog());
        return nullptr;
    }
    // Do create the Sensor object (calling the previous creator)
    return create(server.getNode(), {});
}
\endcode

Creating sensors

Note: Prior to invoking the creation of a sensor of a particular type, you must register the creator for this type into the factory.

To create e.g. a SensorCamera in 3D, you type:

\code
auto camera_ptr = FactorySensorNode::create("SensorCamera", yaml_node);
\endcode

or:

\code
auto camera_ptr = FactorySensorFile::create("SensorCamera", "path_of_params_file.yaml", schema_folders_vector);
\endcode

where ABSOLUTELY ALL input parameters are important. DO NOT USE IT WITH DUMMY PARAMETERS!

We RECOMMEND using the macro WOLF_SENSOR_CREATE(SensorClass) to automatically generate the sensor creators, provided in 'sensor_base.h'.

To do so, you should implement a constructor with the API:

\code
SensorDerived(const YAML::Node& _params)
\endcode

In case of sensors templated to the dimension of the problem (non-type template), there is also the WOLF_SENSOR_TEMPLATE_DIM_CREATE(SensorDerived, DIM). See sensor_odom.h for an example.

Registering sensor creator into the factory

Registration can be done manually or automatically. It involves the call to static functions. It is advisable to put these calls within unnamed namespaces.

• Manual registration: you control registration at application level. Put the code either at global scope (you must define a dummy variable for this),

  namespace {
  const bool registered_camera_node = FactorySensorNode::registerCreator("SensorCamera", SensorCamera::create);
  }
  namespace {
  const bool registered_camera_file = FactorySensorFile::registerCreator("SensorCamera", SensorCamera::create);
  }
  main () { ... }

  or inside your main(), where a direct call is possible:

  main () {
      FactorySensorNode::registerCreator("SensorCamera", SensorCamera::create);
      FactorySensorFile::registerCreator("SensorCamera", SensorCamera::create);
      ...
  }

• Automatic registration: registration is performed at library level. Put the code at the last line of the sensor_xxx.cpp file,

  namespace {
  const bool registered_camera_node = FactorySensorNode::registerCreator("SensorCamera", SensorCamera::create);
  const bool registered_camera_file = FactorySensorFile::registerCreator("SensorCamera", SensorCamera::create);
  }

  Automatic registration is recommended in wolf, and implemented in the classes shipped with it using the macro WOLF_REGISTER_SENSOR(SensorType). You are free to comment out these lines and place them wherever you consider it more convenient for your design.

Creating sensors

We finally provide the necessary steps to create a sensor of class SensorCamera in our application:

#include "vision/sensor/sensor_camera.h" // provides SensorCamera
 
// Note: SensorCamera::create() is already registered, automatically.
 
using namespace wolf;
int main() {
 
    // To create a camera, provide:
    //    a type = "SensorCamera",
    //    a name = "Front-left camera",
    //    the problem dimension dim = 3, and
    //    the yaml node or a yaml file
 
    SensorBasePtr camera_1_ptr =
        FactorySensorNode::create ( "SensorCamera",
                                parameter_node );
 
    // A second camera... with a different name specified in the yaml file or the parameters!
 
    SensorBasePtr camera_2_ptr =
        FactorySensorNode::create( "SensorCamera" ,
                               yaml_filename );
 
    return 0;
}

See also

• Problem::installSensor() : to install sensors in WOLF Problem.

FactorySolverFile

typedef Factory<std::shared_ptr<SolverManager>, const ProblemPtr&, const std::string&, const std::vector<std::string>&> wolf::FactorySolverFile

FactorySolverNode

typedef Factory<std::shared_ptr<SolverManager>, const ProblemPtr&, const YAML::Node&, const std::vector<std::string>&> wolf::FactorySolverNode

Solver factory class.

FactoryStateBlock

typedef Factory<std::shared_ptr<StateBlock>, const Eigen::VectorXd&, bool> wolf::FactoryStateBlock

StateBlock factory class.

This factory can create objects of class StateBlock and classes deriving from StateBlock.

Specific object creation is invoked by create(TYPE, state, fixed), and the TYPE of state block is identified with a string. For example, the following processor types are implemented,

• "StateBlock" for StateBlock
• "StatePoint3d" for StatePoint3d
• "StatePoint2d" for StatePoint2d
• "StateQuaternion" for StateQuaternion
• "StateAngle" for StateAngle
• "StateHomogeneous3d" for StateHomogeneous3d

Find general Factory documentation in class Factory:

• Access the factory
• Register/unregister creators
• Invoke object creation

This documentation shows you how to use the FactoryStateBlock specifically:

• Write a state block creator
• Create state blocks

Write state block creators

StateBlock creators have the following API:

\code
static StateBlockPtr create(const Eigen::VectorXd& _state, bool _fixed);
\endcode

They follow the general implementation shown below:

\code
 static StateBlockPtr create(const Eigen::VectorXd& _state, bool _fixed)
 {
     return std::make_shared<StateBlockDerived>(_state, _fixed);
 }
\endcode

Examples:

To create a StateQuaternion, you type:

\code
auto sq_ptr = FactoryStateBlock::create("StateQuaternion", Vector4d(1,0,0,0), false);
\endcode

To create StateBlocks to store 2D position and velocity, you type:

\code
auto sp2_ptr = FactoryStateBlock::create("StatePoint2d", Vector2d(1,2), false);
auto sv2_ptr = FactoryStateBlock::create("StateVector2d", Vector2d(1,2), false);
\endcode

FactoryStateBlockIdentity

typedef Factory<std::shared_ptr<StateBlock>, bool> wolf::FactoryStateBlockIdentity

FactoryStateBlockIdentityVector

typedef Factory<Eigen::VectorXd> wolf::FactoryStateBlockIdentityVector

FactoryTreeManagerFile

typedef Factory<std::shared_ptr<TreeManagerBase>, const std::string&, const std::vector<std::string>&> wolf::FactoryTreeManagerFile

FactoryTreeManagerNode

typedef Factory<std::shared_ptr<TreeManagerBase>, const YAML::Node&, const std::vector<std::string>&> wolf::FactoryTreeManagerNode

FeatureMatchMap

typedef std::map<FeatureBasePtr, FeatureMatchPtr> wolf::FeatureMatchMap

Map of feature matches.

corr feature <-----------— actual feature

map<FeatureBasePtr actual_feature, FeatureMatchPtr corresponding_feature_match>

FrameConstPtrMap

typedef std::map<TimeStamp, FrameBaseConstPtr> wolf::FrameConstPtrMap

FramePtrMap

typedef std::map<TimeStamp, FrameBasePtr> wolf::FramePtrMap

Landmark2d

typedef Landmark<2> wolf::Landmark2d

Landmark3d

typedef Landmark<3> wolf::Landmark3d

LandmarkMatchMap

typedef std::map<FeatureBasePtr, LandmarkMatchPtr> wolf::LandmarkMatchMap

LoaderPtr

typedef std::shared_ptr<Loader> wolf::LoaderPtr

LocalParametrizationHomogeneous

typedef LocalParametrizationQuaternion<DQ_LOCAL> wolf::LocalParametrizationHomogeneous

Local parametrization for homogeneous vectors is equivalent to quaternion local parametrization.

This is proposed in: https://ieeexplore.ieee.org/document/8594206 (even though we already used it in WOLF before)

LocalParametrizationQuaternionGlobal

typedef LocalParametrizationQuaternion<DQ_GLOBAL> wolf::LocalParametrizationQuaternionGlobal

LocalParametrizationQuaternionLocal

typedef LocalParametrizationQuaternion<DQ_LOCAL> wolf::LocalParametrizationQuaternionLocal

ManifoldWrapperPtr

using wolf::ManifoldWrapperPtr = typedef std::shared_ptr<ManifoldWrapper>

PriorComposite

typedef Composite<Prior> wolf::PriorComposite

ProcessorPose2d

typedef ProcessorPose<2> wolf::ProcessorPose2d

ProcessorPose3d

typedef ProcessorPose<3> wolf::ProcessorPose3d

SensorOdom2d

typedef SensorOdom<2> wolf::SensorOdom2d

SensorOdom3d

typedef SensorOdom<3> wolf::SensorOdom3d

SensorPose2d

typedef SensorPose<2> wolf::SensorPose2d

SensorPose3d

typedef SensorPose<3> wolf::SensorPose3d

SizeEigen

typedef EIGEN_DEFAULT_DENSE_INDEX_TYPE wolf::SizeEigen

Vector and Matrices size type for the Wolf project.

We use the default defined in Eigen (std::ptrdiff_t, a signed integer)

SizeStd

typedef std::size_t wolf::SizeStd

Other containers size type for the Wolf project.

We use the default defined in std (std::size_t, an unsigned integer)

Snapshot

typedef map<SizeStd, FeatureBasePtr> wolf::Snapshot

SnapshotConst

typedef map<SizeStd, FeatureBaseConstPtr> wolf::SnapshotConst

StateKeys

typedef std::string wolf::StateKeys

StateParams1

typedef StateParams<1> wolf::StateParams1

StateParams10

typedef StateParams<10> wolf::StateParams10

StateParams11

typedef StateParams<11> wolf::StateParams11

StateParams12

typedef StateParams<12> wolf::StateParams12

StateParams13

typedef StateParams<13> wolf::StateParams13

StateParams14

typedef StateParams<14> wolf::StateParams14

StateParams15

typedef StateParams<15> wolf::StateParams15

StateParams16

typedef StateParams<16> wolf::StateParams16

StateParams17

typedef StateParams<17> wolf::StateParams17

StateParams18

typedef StateParams<18> wolf::StateParams18

StateParams19

typedef StateParams<19> wolf::StateParams19

StateParams2

typedef StateParams<2> wolf::StateParams2

StateParams20

typedef StateParams<20> wolf::StateParams20

StateParams3

typedef StateParams<3> wolf::StateParams3

StateParams4

typedef StateParams<4> wolf::StateParams4

StateParams5

typedef StateParams<5> wolf::StateParams5

StateParams6

typedef StateParams<6> wolf::StateParams6

StateParams7

typedef StateParams<7> wolf::StateParams7

StateParams8

typedef StateParams<8> wolf::StateParams8

StateParams9

typedef StateParams<9> wolf::StateParams9

Track

typedef map<TimeStamp, FeatureBasePtr> wolf::Track

TrackConst

typedef map<TimeStamp, FeatureBaseConstPtr> wolf::TrackConst

TrackMatches

typedef map<SizeStd, pair<FeatureBasePtr, FeatureBasePtr> > wolf::TrackMatches

TrackMatchesConst

typedef map<SizeStd, pair<FeatureBaseConstPtr, FeatureBaseConstPtr> > wolf::TrackMatchesConst

TypeComposite

typedef Composite<std::string> wolf::TypeComposite

Enumeration Type Documentation

FactorStatus

enum wolf::FactorStatus

Enumeration of factor status.

You may add items to this list as needed. Be concise with names, and document your entries.

Enumerator
FAC_INACTIVE	Inactive factor, it is not included in the SLAM problem.
FAC_ACTIVE	Normal active factor, playing its role in the solution.

FactorTopology

enum wolf::FactorTopology

Enumeration of factor topologies.

You may add items to this list as needed. Be concise with names, and document your entries.

Enumerator
TOP_ABS	absolute factor
TOP_MOTION	motion factor, e.g. odometry, IMU
TOP_LOOP	loop closure factor
TOP_LMK	landmark observation factor
TOP_GEOM	some geometric relation, e.g. distance
TOP_OTHER	other topologies

JacobianMethod

enum wolf::JacobianMethod

Enumeration of jacobian computation method.

You may add items to this list as needed. Be concise with names, and document your entries.

Enumerator
JAC_AUTO	Auto differentiation (AutoDiffCostFunctionWrapper or ceres::NumericDiffCostFunction).
JAC_NUMERIC	Numeric differentiation (ceres::NumericDiffCostFunction).
JAC_ANALYTIC	Analytic jacobians.

Notification

enum wolf::Notification

Enumerator
ADD
REMOVE

QuaternionDeltaReference

enum wolf::QuaternionDeltaReference

Local or global orientation error.

Local or global orientation error.

This enum controls whether the orientation error is composed locally or globally to an orientation specification.

See LocalParametrizationQuaternion for more information.

Enumerator
DQ_LOCAL
DQ_GLOBAL

Function Documentation

between()

template<typename D1 , typename D2 , typename D3 , typename D4 , typename D5 >

void wolf::between ( const Eigen::QuaternionBase< D1 > &  _q1, const Eigen::QuaternionBase< D2 > &  _q2, Eigen::QuaternionBase< D3 > &  _q_between, Eigen::MatrixBase< D4 > &  _J_between_q1, Eigen::MatrixBase< D5 > &  _J_between_q2  )

inline

checkTypeComposite()

void wolf::checkTypeComposite ( const TypeComposite &  _types, SizeEigen  _dim = 0  )

inline

compose()

template<typename D1 , typename D2 , typename D3 , typename D4 , typename D5 >

void wolf::compose ( const Eigen::QuaternionBase< D1 > &  _q1, const Eigen::QuaternionBase< D2 > &  _q2, Eigen::QuaternionBase< D3 > &  _q_comp, Eigen::MatrixBase< D4 > &  _J_comp_q1, Eigen::MatrixBase< D5 > &  _J_comp_q2  )

inline

computeSqrtUpper()

Eigen::MatrixXd wolf::computeSqrtUpper ( const Eigen::MatrixXd &  _info )

inline

createNumericDiffCostFunction()

std::shared_ptr< ceres::CostFunction > wolf::createNumericDiffCostFunction ( FactorBasePtr  _fac_ptr )

inline

createNumericDiffCostFunctionCeres()

template<class T >

std::shared_ptr< ceres::NumericDiffCostFunction< T, ceres::CENTRAL, T::residualSize, T::block0Size, T::block1Size, T::block2Size, T::block3Size, T::block4Size, T::block5Size, T::block6Size, T::block7Size, T::block8Size, T::block9Size > > wolf::createNumericDiffCostFunctionCeres

(

FactorBasePtr

_factor_ptr

)

dateTimeNow()

std::string wolf::dateTimeNow ( )

inline

diff()

template<typename D1 , typename D2 >

Eigen::Matrix< typename D2::Scalar, 3, 1 > wolf::diff ( const Eigen::QuaternionBase< D1 > &  q1, const Eigen::QuaternionBase< D2 > &  q2  )

inline

e2q()

template<typename D >

Eigen::Quaternion< typename D::Scalar > wolf::e2q ( const Eigen::MatrixBase< D > &  _euler )

inline

Euler angles to quaternion.

Parameters

_euler

= (roll pitch yaw) in ZYX convention

Returns

equivalent quaternion

e2R()

template<typename Derived >

Eigen::Matrix< typename Derived::Scalar, 3, 3 > wolf::e2R ( const Eigen::MatrixBase< Derived > &  _e )

inline

Euler angles to rotation matrix.

Parameters

_e	= (roll pitch yaw) in ZYX convention

Returns

equivalent rotation matrix

exp_q()

template<typename Derived >

Eigen::Quaternion< typename Derived::Scalar > wolf::exp_q ( const Eigen::MatrixBase< Derived > &  _v )

inline

Quaternion exponential map.

Parameters

_v	a rotation vector with _v.norm() the rotated angle and _v.normalized() the rotation axis.

Returns

the right-handed unit quaternion performing the rotation encoded by _v

exp_R()

template<typename Derived >

Eigen::Matrix< typename Derived::Scalar, 3, 3 > wolf::exp_R ( const Eigen::MatrixBase< Derived > &  _v )

inline

Rotation matrix exponential map.

Parameters

_v	a rotation vector

Returns

the rotation matrix performing the rotation encoded by _v

file_exists()

bool wolf::file_exists ( const std::string &  _name )

inline

getYaw() [1/2]

template<typename Derived >

Eigen::MatrixBase< Derived >::Scalar wolf::getYaw ( const Eigen::MatrixBase< Derived > &  _M )

inline

getYaw() [2/2]

template<typename Derived >

Eigen::QuaternionBase< Derived >::Scalar wolf::getYaw ( const Eigen::QuaternionBase< Derived > &  _q )

inline

gravity()

const Eigen::Vector3d wolf::gravity ( void  )

inline

insertSparseBlock()

void wolf::insertSparseBlock	(	const Eigen::MatrixXd &	ins,
		Eigen::SparseMatrixd &	original,
		const unsigned int &	row,
		const unsigned int &	col
	)

inverseProjectTo3d()

Eigen::Isometry3d wolf::inverseProjectTo3d ( const Eigen::Isometry2d &  trf_2d )

inline

isCovariance()

template<typename T , int N, int RC>

bool wolf::isCovariance ( const Eigen::Matrix< T, N, N, RC > &  M, const T &  eps = Constants::EPS  )

inline

isPositiveSemiDefinite()

template<typename T , int N, int RC>

bool wolf::isPositiveSemiDefinite ( const Eigen::Matrix< T, N, N, RC > &  M, const T &  eps = Constants::EPS  )

inline

isSymmetric()

template<typename T , int N, int RC>

bool wolf::isSymmetric ( const Eigen::Matrix< T, N, N, RC > &  M, const T  eps = wolf::Constants::EPS  )

inline

isTypeCompositeValid()

bool wolf::isTypeCompositeValid ( const TypeComposite &  _types, SizeEigen  _dim = 0  )

inline

jac_SO3_left()

template<typename Derived >

Eigen::Matrix< typename Derived::Scalar, 3, 3 > wolf::jac_SO3_left ( const Eigen::MatrixBase< Derived > &  _theta )

inline

Compute Jl (Left Jacobian) Left Jacobian for exp map in SO(3) - equation (10.86) and following equations in G.S. Chirikjian, "Stochastic Models, Information Theory, and Lie Groups", Volume 2, 2008.

expmap( theta + d_theta ) \approx expmap(Jl * d_theta) * expmap(theta)

where Jl = jac_SO3_left(theta);

This maps a perturbation in the tangent space (d_theta) to a perturbation on the manifold (expmap(Jl * d_theta)) so that:

exp(theta+d_theta) = exp(Jl(theta)*d_theta)*exp(theta)

jac_SO3_left_inv()

template<typename Derived >

Eigen::Matrix< typename Derived::Scalar, 3, 3 > wolf::jac_SO3_left_inv ( const Eigen::MatrixBase< Derived > &  _theta )

inline

Compute Jl_inv (inverse of Left Jacobian which corresponds to the jacobian of log) Left Jacobian for Log map in SO(3) - equation (10.86) and following equations in G.S. Chirikjian, "Stochastic Models, Information Theory, and Lie Groups", Volume 2, 2008.

logmap( expmap(d_theta) * R ) \approx logmap( R ) + Jlinv * d_theta

where Jlinv = jac_SO3_left_inv(theta);

This maps a perturbation on the manifold (expmap(theta)) to a perturbation in the tangent space (Jlinv * theta) so that

 log( exp(d_theta) * exp(theta) ) = theta + Jlinv(theta) * d_theta

or, having R = exp(theta),

log( exp(d_theta) * R ) = log(R) + Jlinv(theta) * d_theta

jac_SO3_right()

template<typename Derived >

Eigen::Matrix< typename Derived::Scalar, 3, 3 > wolf::jac_SO3_right ( const Eigen::MatrixBase< Derived > &  _theta )

inline

Compute Jr (Right Jacobian) Right Jacobian for exp map in SO(3) - equation (10.86) and following equations in G.S. Chirikjian, "Stochastic Models, Information Theory, and Lie Groups", Volume 2, 2008.

expmap( theta + d_theta ) \approx expmap(theta) * expmap(Jr * d_theta)

where Jr = jac_SO3_right(theta);

This maps a perturbation in the tangent space (d_theta) to a perturbation on the manifold (expmap(Jr * d_theta)) so that:

exp(theta+d_theta) = exp(theta)*exp(Jr(theta)*d_theta)

jac_SO3_right_inv()

template<typename Derived >

Eigen::Matrix< typename Derived::Scalar, 3, 3 > wolf::jac_SO3_right_inv ( const Eigen::MatrixBase< Derived > &  _theta )

inline

Compute Jrinv (inverse of Right Jacobian which corresponds to the jacobian of log) Right Jacobian for Log map in SO(3) - equation (10.86) and following equations in G.S. Chirikjian, "Stochastic Models, Information Theory, and Lie Groups", Volume 2, 2008.

logmap( R * expmap(d_theta) ) \approx logmap( R ) + Jrinv * d_theta
logmap( q * expmap(d_theta) ) \approx logmap( q ) + Jrinv * d_theta

where Jrinv = jac_SO3_right_inv(theta);

This maps a perturbation on the manifold (expmap(theta)) to a perturbation in the tangent space (Jrinv * theta) so that

 log( exp(theta) * exp(d_theta) ) = theta + Jrinv(theta) * d_theta

or, having R = exp(theta),

log( R * exp(d_theta) ) = log(R) + Jrinv(theta) * d_theta

keysIntersection()

StateKeys wolf::keysIntersection	(	const StateKeys &	_keys1,
		const StateKeys &	_keys2
	)

Intersection of two sets of keys: the keys of _keys1 that are also in _keys2, in the order of _keys1 (no duplicates)

keysUnion()

StateKeys wolf::keysUnion	(	const StateKeys &	_keys1,
		const StateKeys &	_keys2
	)

Union of two sets of keys: the keys of _keys1 followed by the keys of _keys2 not in _keys1 (no duplicates) Note: 'union' is a C++ keyword.

log_q()

template<typename Derived >

Eigen::Matrix< typename Derived::Scalar, 3, 1 > wolf::log_q ( const Eigen::QuaternionBase< Derived > &  _q )

inline

Quaternion logarithmic map.

Parameters

_q	a unit right-handed quaternion

Returns

a rotation vector v such that _q = exp_q(v)

log_R()

template<typename Derived >

Eigen::Matrix< typename Derived::Scalar, 3, 1 > wolf::log_R ( const Eigen::MatrixBase< Derived > &  _R )

inline

Rotation matrix logarithmic map.

Parameters

_R	a 3d rotation matrix

Returns

the rotation vector v such that _R = exp_R(v)

makePosDef()

template<typename T , int N, int RC>

bool wolf::makePosDef ( Eigen::Matrix< T, N, N, RC > &  M, const T &  eps = Constants::EPS  )

inline

minus()

template<typename D1 , typename D2 >

Eigen::Matrix< typename D2::Scalar, 3, 1 > wolf::minus ( const Eigen::QuaternionBase< D1 > &  q1, const Eigen::QuaternionBase< D2 > &  q2  )

inline

minus_left()

template<typename D1 , typename D2 >

Eigen::Matrix< typename D2::Scalar, 3, 1 > wolf::minus_left ( const Eigen::QuaternionBase< D1 > &  q1, const Eigen::QuaternionBase< D2 > &  q2  )

inline

minus_right()

template<typename D1 , typename D2 >

Eigen::Matrix< typename D2::Scalar, 3, 1 > wolf::minus_right ( const Eigen::QuaternionBase< D1 > &  q1, const Eigen::QuaternionBase< D2 > &  q2  )

inline

operator<<() [1/3]

std::ostream & wolf::operator<<	(	std::ostream &	_os,
		const wolf::Prior &	_x
	)

operator<<() [2/3]

std::ostream & wolf::operator<<	(	std::ostream &	_os,
		const wolf::VectorComposite &	_x
	)

operator<<() [3/3]

std::ostream & wolf::operator<<	(	std::ostream &	os,
		const TimeStamp &	_ts
	)

pi2pi()

template<typename T >

T wolf::pi2pi ( const T &  _angle )

inline

Return angle between -pi and pi This implementation uses std::remainder which makes it incompatible for autodiff::Jet (this implementation was included in math/autodiff/wolf_jet.h)

Parameters

angle

Returns

formatted angle

plus()

template<typename D1 , typename D2 >

Eigen::Quaternion< typename D1::Scalar > wolf::plus ( const Eigen::QuaternionBase< D1 > &  q, const Eigen::MatrixBase< D2 > &  v  )

inline

plus_left()

template<typename D1 , typename D2 >

Eigen::Quaternion< typename D1::Scalar > wolf::plus_left ( const Eigen::MatrixBase< D2 > &  v, const Eigen::QuaternionBase< D1 > &  q  )

inline

plus_right()

template<typename D1 , typename D2 >

Eigen::Quaternion< typename D1::Scalar > wolf::plus_right ( const Eigen::QuaternionBase< D1 > &  q, const Eigen::MatrixBase< D2 > &  v  )

inline

projectTo2d()

Eigen::Isometry2d wolf::projectTo2d ( const Eigen::Isometry3d &  trf_3d )

inline

q2e() [1/2]

template<typename Derived >

Eigen::Matrix< typename Derived::Scalar, 3, 1 > wolf::q2e ( const Eigen::MatrixBase< Derived > &  _q )

inline

q2e() [2/2]

template<typename Derived >

Eigen::Matrix< typename Derived::Scalar, 3, 1 > wolf::q2e ( const Eigen::QuaternionBase< Derived > &  _q )

inline

q2R() [1/2]

template<typename Derived >

Eigen::Matrix< typename Derived::Scalar, 3, 3 > wolf::q2R ( const Eigen::MatrixBase< Derived > &  _q )

inline

quaternion to rotation matrix conversion

Parameters

_q	a right-handed unit quaternion

Returns

the equivalent rotation matrix

q2R() [2/2]

template<typename Derived >

Eigen::Matrix< typename Derived::Scalar, 3, 3 > wolf::q2R ( const Eigen::QuaternionBase< Derived > &  _q )

inline

quaternion to rotation matrix conversion

Parameters

_q	a right-handed unit quaternion

Returns

the equivalent rotation matrix

q2v()

template<typename Derived >

Eigen::Matrix< typename Derived::Scalar, 3, 1 > wolf::q2v ( const Eigen::QuaternionBase< Derived > &  _q )

inline

Quaternion to rotation vector conversion.

Parameters

_q	a right-handed unit quaternion

Returns

the equivalent rotation vector

R2e()

template<typename Derived >

Eigen::Matrix< typename Derived::Scalar, 3, 1 > wolf::R2e ( const Eigen::MatrixBase< Derived > &  _R )

inline

R2q()

template<typename Derived >

Eigen::Quaternion< typename Derived::Scalar > wolf::R2q ( const Eigen::MatrixBase< Derived > &  _R )

inline

rotation matrix to quaternion conversion

Parameters

_R	a rotation matrix

Returns

the equivalent right-handed unit quaternion

R2v()

template<typename Derived >

Eigen::Matrix< typename Derived::Scalar, 3, 1 > wolf::R2v ( const Eigen::MatrixBase< Derived > &  _R )

inline

Rotation matrix to rotation vector conversion.

Parameters

_R	a rotation matrix

Returns

the equivalent rotation vector

secondsSince()

static double wolf::secondsSince ( const std::chrono::steady_clock::time_point &  _t )

static

skew()

template<typename Derived >

Eigen::Matrix< typename Derived::Scalar, 3, 3 > wolf::skew ( const Eigen::MatrixBase< Derived > &  _v )

inline

Skew symmetric matrix.

Parameters

_v	a 3d vector

Returns

the skew-symmetric matrix V so that V*u = _v.cross(u), for u in R^3

stringPrintf()

static std::string wolf::stringPrintf ( const char *  format,   ...  )

static

toDeg()

template<typename T >

T wolf::toDeg ( const T  rad )

inline

Conversion to degrees.

Parameters

rad	angle in radians

Returns

angle in degrees

toIsometry2d() [1/4]

template<typename D1 >

Eigen::Transform< typename D1::Scalar, 2, Eigen::Isometry > wolf::toIsometry2d ( const Eigen::MatrixBase< D1 > &  translation, const double &  rotation  )

inline

toIsometry2d() [2/4]

template<typename D1 , typename D2 >

Eigen::Transform< typename D1::Scalar, 2, Eigen::Isometry > wolf::toIsometry2d ( const Eigen::MatrixBase< D1 > &  translation, const Eigen::MatrixBase< D2 > &  rotation  )

inline

toIsometry2d() [3/4]

template<typename D1 >

Eigen::Transform< typename D1::Scalar, 2, Eigen::Isometry > wolf::toIsometry2d ( const Eigen::MatrixBase< D1 > &  trf )

inline

toIsometry2d() [4/4]

Eigen::Isometry2d wolf::toIsometry2d ( const VectorComposite &  trf )

inline

toIsometry3d() [1/4]

template<typename D1 , typename D2 >

Eigen::Transform< typename D1::Scalar, 3, Eigen::Isometry > wolf::toIsometry3d ( const Eigen::MatrixBase< D1 > &  translation, const Eigen::MatrixBase< D2 > &  rotation  )

inline

toIsometry3d() [2/4]

template<typename D1 , typename D2 >

Eigen::Transform< typename D1::Scalar, 3, Eigen::Isometry > wolf::toIsometry3d ( const Eigen::MatrixBase< D1 > &  translation, const Eigen::QuaternionBase< D2 > &  rotation  )

inline

toIsometry3d() [3/4]

template<typename D1 >

Eigen::Transform< typename D1::Scalar, 3, Eigen::Isometry > wolf::toIsometry3d ( const Eigen::MatrixBase< D1 > &  trf )

inline

toIsometry3d() [4/4]

Eigen::Isometry3d wolf::toIsometry3d ( const VectorComposite &  trf )

inline

toRad()

template<typename T >

T wolf::toRad ( const T  deg )

inline

Conversion to radians.

Parameters

deg	angle in degrees

Returns

angle in radians

toVector() [1/2]

Eigen::Vector3d wolf::toVector ( const Eigen::Isometry2d &  trf )

inline

toVector() [2/2]

Eigen::Vector7d wolf::toVector ( const Eigen::Isometry3d &  trf )

inline

v2q()

template<typename Derived >

Eigen::Quaternion< typename Derived::Scalar > wolf::v2q ( const Eigen::MatrixBase< Derived > &  _v )

inline

Rotation vector to quaternion conversion.

Parameters

_v	a rotation vector

Returns

the equivalent right-handed unit quaternion

v2R()

template<typename Derived >

Eigen::Matrix< typename Derived::Scalar, 3, 3 > wolf::v2R ( const Eigen::MatrixBase< Derived > &  _v )

inline

Rotation vector to rotation matrix conversion.

Parameters

_v	a rotation vector

Returns

the equivalent rotation matrix

vee()

template<typename Derived >

Eigen::Matrix< typename Derived::Scalar, 3, 1 > wolf::vee ( const Eigen::MatrixBase< Derived > &  _m )

inline

Inverse of skew symmetric matrix.

Parameters

_m	A skew-symmetric matrix

Returns

a 3-vector v such that skew(v) = _m

WOLF_DECLARED_PTR_TYPEDEFS() [1/8]

wolf::WOLF_DECLARED_PTR_TYPEDEFS

(

Landmark2d

)

WOLF_DECLARED_PTR_TYPEDEFS() [2/8]

wolf::WOLF_DECLARED_PTR_TYPEDEFS

(

Landmark3d

)

WOLF_DECLARED_PTR_TYPEDEFS() [3/8]

wolf::WOLF_DECLARED_PTR_TYPEDEFS

(

ProcessorPose2d

)

WOLF_DECLARED_PTR_TYPEDEFS() [4/8]

wolf::WOLF_DECLARED_PTR_TYPEDEFS

(

ProcessorPose3d

)

WOLF_DECLARED_PTR_TYPEDEFS() [5/8]

wolf::WOLF_DECLARED_PTR_TYPEDEFS

(

SensorOdom2d

)

WOLF_DECLARED_PTR_TYPEDEFS() [6/8]

wolf::WOLF_DECLARED_PTR_TYPEDEFS

(

SensorOdom3d

)

WOLF_DECLARED_PTR_TYPEDEFS() [7/8]

wolf::WOLF_DECLARED_PTR_TYPEDEFS

(

SensorPose2d

)

WOLF_DECLARED_PTR_TYPEDEFS() [8/8]

wolf::WOLF_DECLARED_PTR_TYPEDEFS

(

SensorPose3d

)

WOLF_PTR_TYPEDEFS() [1/64]

wolf::WOLF_PTR_TYPEDEFS

(

CaptureBase

)

WOLF_PTR_TYPEDEFS() [2/64]

wolf::WOLF_PTR_TYPEDEFS

(

CaptureLandmarksExternal

)

WOLF_PTR_TYPEDEFS() [3/64]

wolf::WOLF_PTR_TYPEDEFS

(

CaptureMotion

)

WOLF_PTR_TYPEDEFS() [4/64]

wolf::WOLF_PTR_TYPEDEFS

(

CaptureOdom2d

)

WOLF_PTR_TYPEDEFS() [5/64]

wolf::WOLF_PTR_TYPEDEFS

(

CaptureOdom3d

)

WOLF_PTR_TYPEDEFS() [6/64]

wolf::WOLF_PTR_TYPEDEFS

(

CapturePose

)

WOLF_PTR_TYPEDEFS() [7/64]

wolf::WOLF_PTR_TYPEDEFS

(

CostFunctionWrapper

)

WOLF_PTR_TYPEDEFS() [8/64]

wolf::WOLF_PTR_TYPEDEFS

(

FactorAnalytic

)

WOLF_PTR_TYPEDEFS() [9/64]

wolf::WOLF_PTR_TYPEDEFS

(

FactorBase

)

WOLF_PTR_TYPEDEFS() [10/64]

wolf::WOLF_PTR_TYPEDEFS

(

FactorBlockAbsolute

)

WOLF_PTR_TYPEDEFS() [11/64]

wolf::WOLF_PTR_TYPEDEFS

(

FactorBlockDifference

)

WOLF_PTR_TYPEDEFS() [12/64]

wolf::WOLF_PTR_TYPEDEFS

(

FactorDiffDrive

)

WOLF_PTR_TYPEDEFS() [13/64]

wolf::WOLF_PTR_TYPEDEFS

(

FactorDistance3d

)

WOLF_PTR_TYPEDEFS() [14/64]

wolf::WOLF_PTR_TYPEDEFS

(

FactorHomogeneous3dAbsolute

)

WOLF_PTR_TYPEDEFS() [15/64]

wolf::WOLF_PTR_TYPEDEFS

(

FactorPose2d

)

WOLF_PTR_TYPEDEFS() [16/64]

wolf::WOLF_PTR_TYPEDEFS

(

FactorPose2dWithExtrinsics

)

WOLF_PTR_TYPEDEFS() [17/64]

wolf::WOLF_PTR_TYPEDEFS

(

FactorPose3d

)

WOLF_PTR_TYPEDEFS() [18/64]

wolf::WOLF_PTR_TYPEDEFS

(

FactorPose3dWithExtrinsics

)

WOLF_PTR_TYPEDEFS() [19/64]

wolf::WOLF_PTR_TYPEDEFS

(

FactorQuaternionAbsolute

)

WOLF_PTR_TYPEDEFS() [20/64]

wolf::WOLF_PTR_TYPEDEFS

(

FactorQuaternionDifference

)

WOLF_PTR_TYPEDEFS() [21/64]

wolf::WOLF_PTR_TYPEDEFS

(

FactorRelativePose2d

)

WOLF_PTR_TYPEDEFS() [22/64]

wolf::WOLF_PTR_TYPEDEFS

(

FactorRelativePose2dWithExtrinsics

)

WOLF_PTR_TYPEDEFS() [23/64]

wolf::WOLF_PTR_TYPEDEFS

(

FactorRelativePose3d

)

WOLF_PTR_TYPEDEFS() [24/64]

wolf::WOLF_PTR_TYPEDEFS

(

FactorRelativePose3dWithExtrinsics

)

WOLF_PTR_TYPEDEFS() [25/64]

wolf::WOLF_PTR_TYPEDEFS

(

FactorRelativePosition2d

)

WOLF_PTR_TYPEDEFS() [26/64]

wolf::WOLF_PTR_TYPEDEFS

(

FactorRelativePosition2dWithExtrinsics

)

WOLF_PTR_TYPEDEFS() [27/64]

wolf::WOLF_PTR_TYPEDEFS

(

FactorRelativePosition3d

)

WOLF_PTR_TYPEDEFS() [28/64]

wolf::WOLF_PTR_TYPEDEFS

(

FactorRelativePosition3dWithExtrinsics

)

WOLF_PTR_TYPEDEFS() [29/64]

wolf::WOLF_PTR_TYPEDEFS

(

FactorVelocityLocalDirection3d

)

WOLF_PTR_TYPEDEFS() [30/64]

wolf::WOLF_PTR_TYPEDEFS

(

FeatureBase

)

WOLF_PTR_TYPEDEFS() [31/64]

wolf::WOLF_PTR_TYPEDEFS

(

FeatureLandmarkExternal

)

WOLF_PTR_TYPEDEFS() [32/64]

wolf::WOLF_PTR_TYPEDEFS

(

FeatureMotion

)

WOLF_PTR_TYPEDEFS() [33/64]

wolf::WOLF_PTR_TYPEDEFS

(

FrameBase

)

WOLF_PTR_TYPEDEFS() [34/64]

wolf::WOLF_PTR_TYPEDEFS

(

HardwareBase

)

WOLF_PTR_TYPEDEFS() [35/64]

wolf::WOLF_PTR_TYPEDEFS

(

LandmarkBase

)

WOLF_PTR_TYPEDEFS() [36/64]

wolf::WOLF_PTR_TYPEDEFS

(

LocalParametrizationBase

)

WOLF_PTR_TYPEDEFS() [37/64]

wolf::WOLF_PTR_TYPEDEFS

(

ManifoldWrapper

)

WOLF_PTR_TYPEDEFS() [38/64]

wolf::WOLF_PTR_TYPEDEFS

(

MapBase

)

WOLF_PTR_TYPEDEFS() [39/64]

wolf::WOLF_PTR_TYPEDEFS

(

MotionProvider

)

WOLF_PTR_TYPEDEFS() [40/64]

wolf::WOLF_PTR_TYPEDEFS

(

NodeBase

)

WOLF_PTR_TYPEDEFS() [41/64]

wolf::WOLF_PTR_TYPEDEFS

(

NodeStateBlocks

)

WOLF_PTR_TYPEDEFS() [42/64]

wolf::WOLF_PTR_TYPEDEFS

(

Problem

)

WOLF_PTR_TYPEDEFS() [43/64]

wolf::WOLF_PTR_TYPEDEFS

(

ProcessorBase

)

WOLF_PTR_TYPEDEFS() [44/64]

wolf::WOLF_PTR_TYPEDEFS

(

ProcessorDiffDrive

)

WOLF_PTR_TYPEDEFS() [45/64]

wolf::WOLF_PTR_TYPEDEFS

(

ProcessorFixedWingModel

)

WOLF_PTR_TYPEDEFS() [46/64]

wolf::WOLF_PTR_TYPEDEFS

(

ProcessorLandmarkExternal

)

WOLF_PTR_TYPEDEFS() [47/64]

wolf::WOLF_PTR_TYPEDEFS

(

ProcessorMotion

)

WOLF_PTR_TYPEDEFS() [48/64]

wolf::WOLF_PTR_TYPEDEFS

(

ProcessorOdom2d

)

WOLF_PTR_TYPEDEFS() [49/64]

wolf::WOLF_PTR_TYPEDEFS

(

ProcessorOdom3d

)

WOLF_PTR_TYPEDEFS() [50/64]

wolf::WOLF_PTR_TYPEDEFS

(

ProcessorTracker

)

WOLF_PTR_TYPEDEFS() [51/64]

wolf::WOLF_PTR_TYPEDEFS

(

ProcessorTrackerFeature

)

WOLF_PTR_TYPEDEFS() [52/64]

wolf::WOLF_PTR_TYPEDEFS

(

ProcessorTrackerLandmark

)

WOLF_PTR_TYPEDEFS() [53/64]

wolf::WOLF_PTR_TYPEDEFS

(

SensorBase

)

WOLF_PTR_TYPEDEFS() [54/64]

wolf::WOLF_PTR_TYPEDEFS

(

SensorDiffDrive

)

WOLF_PTR_TYPEDEFS() [55/64]

wolf::WOLF_PTR_TYPEDEFS

(

SensorMotionModel

)

WOLF_PTR_TYPEDEFS() [56/64]

wolf::WOLF_PTR_TYPEDEFS

(

SolverCeres

)

WOLF_PTR_TYPEDEFS() [57/64]

wolf::WOLF_PTR_TYPEDEFS

(

SolverEigen

)

WOLF_PTR_TYPEDEFS() [58/64]

wolf::WOLF_PTR_TYPEDEFS

(

StateAngle

)

WOLF_PTR_TYPEDEFS() [59/64]

wolf::WOLF_PTR_TYPEDEFS

(

StateBlock

)

WOLF_PTR_TYPEDEFS() [60/64]

wolf::WOLF_PTR_TYPEDEFS

(

StatePoint2d

)

WOLF_PTR_TYPEDEFS() [61/64]

wolf::WOLF_PTR_TYPEDEFS

(

StatePoint3d

)

WOLF_PTR_TYPEDEFS() [62/64]

wolf::WOLF_PTR_TYPEDEFS

(

StateQuaternion

)

WOLF_PTR_TYPEDEFS() [63/64]

wolf::WOLF_PTR_TYPEDEFS

(

TrajectoryBase

)

WOLF_PTR_TYPEDEFS() [64/64]

wolf::WOLF_PTR_TYPEDEFS

(

TreeManagerBase

)

WOLF_REGISTER_FOLDER()

wolf::WOLF_REGISTER_FOLDER	(	"core"	,
		_WOLF_SCHEMA_DIR
	)

WOLF_REGISTER_LANDMARK() [1/2]

wolf::WOLF_REGISTER_LANDMARK

(

Landmark2d

)

WOLF_REGISTER_LANDMARK() [2/2]

wolf::WOLF_REGISTER_LANDMARK

(

Landmark3d

)

WOLF_REGISTER_MAP()

wolf::WOLF_REGISTER_MAP

(

MapBase

)

WOLF_REGISTER_PROCESSOR() [1/6]

wolf::WOLF_REGISTER_PROCESSOR

(

ProcessorDiffDrive

)

WOLF_REGISTER_PROCESSOR() [2/6]

wolf::WOLF_REGISTER_PROCESSOR

(

ProcessorFixedWingModel

)

WOLF_REGISTER_PROCESSOR() [3/6]

wolf::WOLF_REGISTER_PROCESSOR

(

ProcessorOdom2d

)

WOLF_REGISTER_PROCESSOR() [4/6]

wolf::WOLF_REGISTER_PROCESSOR

(

ProcessorOdom3d

)

WOLF_REGISTER_PROCESSOR() [5/6]

wolf::WOLF_REGISTER_PROCESSOR

(

ProcessorPose2d

)

WOLF_REGISTER_PROCESSOR() [6/6]

wolf::WOLF_REGISTER_PROCESSOR

(

ProcessorPose3d

)

WOLF_REGISTER_SENSOR() [1/6]

wolf::WOLF_REGISTER_SENSOR

(

SensorDiffDrive

)

WOLF_REGISTER_SENSOR() [2/6]

wolf::WOLF_REGISTER_SENSOR

(

SensorMotionModel

)

WOLF_REGISTER_SENSOR() [3/6]

wolf::WOLF_REGISTER_SENSOR

(

SensorOdom2d

)

WOLF_REGISTER_SENSOR() [4/6]

wolf::WOLF_REGISTER_SENSOR

(

SensorOdom3d

)

WOLF_REGISTER_SENSOR() [5/6]

wolf::WOLF_REGISTER_SENSOR

(

SensorPose2d

)

WOLF_REGISTER_SENSOR() [6/6]

wolf::WOLF_REGISTER_SENSOR

(

SensorPose3d

)

WOLF_REGISTER_STATEBLOCK() [1/27]

wolf::WOLF_REGISTER_STATEBLOCK

(

StateAngle

)

WOLF_REGISTER_STATEBLOCK() [2/27]

wolf::WOLF_REGISTER_STATEBLOCK

(

StateHomogeneous3d

)

WOLF_REGISTER_STATEBLOCK() [3/27]

wolf::WOLF_REGISTER_STATEBLOCK

(

StateParams1

)

WOLF_REGISTER_STATEBLOCK() [4/27]

wolf::WOLF_REGISTER_STATEBLOCK

(

StateParams10

)

WOLF_REGISTER_STATEBLOCK() [5/27]

wolf::WOLF_REGISTER_STATEBLOCK

(

StateParams11

)

WOLF_REGISTER_STATEBLOCK() [6/27]

wolf::WOLF_REGISTER_STATEBLOCK

(

StateParams12

)

WOLF_REGISTER_STATEBLOCK() [7/27]

wolf::WOLF_REGISTER_STATEBLOCK

(

StateParams13

)

WOLF_REGISTER_STATEBLOCK() [8/27]

wolf::WOLF_REGISTER_STATEBLOCK

(

StateParams14

)

WOLF_REGISTER_STATEBLOCK() [9/27]

wolf::WOLF_REGISTER_STATEBLOCK

(

StateParams15

)

WOLF_REGISTER_STATEBLOCK() [10/27]

wolf::WOLF_REGISTER_STATEBLOCK

(

StateParams16

)

WOLF_REGISTER_STATEBLOCK() [11/27]

wolf::WOLF_REGISTER_STATEBLOCK

(

StateParams17

)

WOLF_REGISTER_STATEBLOCK() [12/27]

wolf::WOLF_REGISTER_STATEBLOCK

(

StateParams18

)

WOLF_REGISTER_STATEBLOCK() [13/27]

wolf::WOLF_REGISTER_STATEBLOCK

(

StateParams19

)

WOLF_REGISTER_STATEBLOCK() [14/27]

wolf::WOLF_REGISTER_STATEBLOCK

(

StateParams2

)

WOLF_REGISTER_STATEBLOCK() [15/27]

wolf::WOLF_REGISTER_STATEBLOCK

(

StateParams20

)

WOLF_REGISTER_STATEBLOCK() [16/27]

wolf::WOLF_REGISTER_STATEBLOCK

(

StateParams3

)

WOLF_REGISTER_STATEBLOCK() [17/27]

wolf::WOLF_REGISTER_STATEBLOCK

(

StateParams4

)

WOLF_REGISTER_STATEBLOCK() [18/27]

wolf::WOLF_REGISTER_STATEBLOCK

(

StateParams5

)

WOLF_REGISTER_STATEBLOCK() [19/27]

wolf::WOLF_REGISTER_STATEBLOCK

(

StateParams6

)

WOLF_REGISTER_STATEBLOCK() [20/27]

wolf::WOLF_REGISTER_STATEBLOCK

(

StateParams7

)

WOLF_REGISTER_STATEBLOCK() [21/27]

wolf::WOLF_REGISTER_STATEBLOCK

(

StateParams8

)

WOLF_REGISTER_STATEBLOCK() [22/27]

wolf::WOLF_REGISTER_STATEBLOCK

(

StateParams9

)

WOLF_REGISTER_STATEBLOCK() [23/27]

wolf::WOLF_REGISTER_STATEBLOCK

(

StatePoint2d

)

WOLF_REGISTER_STATEBLOCK() [24/27]

wolf::WOLF_REGISTER_STATEBLOCK

(

StatePoint3d

)

WOLF_REGISTER_STATEBLOCK() [25/27]

wolf::WOLF_REGISTER_STATEBLOCK

(

StateQuaternion

)

WOLF_REGISTER_STATEBLOCK() [26/27]

wolf::WOLF_REGISTER_STATEBLOCK

(

StateVector2d

)

WOLF_REGISTER_STATEBLOCK() [27/27]

wolf::WOLF_REGISTER_STATEBLOCK

(

StateVector3d

)

WOLF_REGISTER_TREE_MANAGER() [1/2]

wolf::WOLF_REGISTER_TREE_MANAGER

(

TreeManagerSlidingWindow

)

WOLF_REGISTER_TREE_MANAGER() [2/2]

wolf::WOLF_REGISTER_TREE_MANAGER

(

TreeManagerSlidingWindowDualRate

)

WOLF_STRUCT_PTR_TYPEDEFS() [1/3]

wolf::WOLF_STRUCT_PTR_TYPEDEFS

(

FeatureMatch

)

WOLF_STRUCT_PTR_TYPEDEFS() [2/3]

wolf::WOLF_STRUCT_PTR_TYPEDEFS

(

LandmarkMatch

)

WOLF_STRUCT_PTR_TYPEDEFS() [3/3]

wolf::WOLF_STRUCT_PTR_TYPEDEFS

(

MatchLoopClosure

)

Variable Documentation

ALL_KEYS

std::string wolf::ALL_KEYS = " "

static

cauchy_a2

constexpr double wolf::cauchy_a2 = 0.5 * 0.5

staticconstexpr

max_step_halvings

constexpr unsigned int wolf::max_step_halvings = 10

staticconstexpr

NO_ROW

constexpr unsigned int wolf::NO_ROW = std::numeric_limits<unsigned int>::max()

staticconstexpr